home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Plains / Plains Medium.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.8 KB  |  1,537 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Plains Medium.rmv
  4. //
  5. // Plains definitions for gigantic maps.
  6. //
  7. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  8. // PROPRIETARY and CONFIDENTIAL.
  9. //
  10. // $Creator: Richard Bishop $
  11. //
  12. //      V1.0 to V1.2
  13. //        -Pulled in Berries two tiles closer
  14. //      V1.2 to V1.3
  15. //        -Added Tigers to all maps
  16. //        -Added Hippos to all maps
  17. //////////////////////////////////////////////////////////////////////
  18.  
  19. #if            NOTDEFINED(PLAINS_MEDIUM_RMV)
  20. #define        (PLAINS_MEDIUM_RMV,1)
  21.  
  22. //////////////////////////////////////////////////////////////////////
  23. // Resource
  24.  
  25. #if OR(IsPaleoEpoch, IsStoneEpoch) 
  26.   #define  (kBerryPerPlayer,    2)
  27. #else
  28.   #define  (kBerryPerPlayer,    1)
  29. #endif
  30.  
  31.  
  32. //////////////////////////////////////////////////////////////////////
  33. // Resource Limitations
  34.  
  35. ResourcePlacementLimit (Gold,     10,    12)
  36. ResourcePlacementLimit (Steel,     10,     12)
  37. ResourcePlacementLimit (Stone,     13,    14)
  38. ResourcePlacementLimit (Berry,     6,    7)
  39. ResourcePlacementLimit (Tree,     3,    5)
  40.  
  41. //////////////////////////////////////////////////////////////////////
  42. // Placing Starting Hippos
  43.  
  44. #if DEFINED(kWinterMap)
  45.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  46.   PlaceWorldUnitInRing (Res-Walrus, 12, 12)
  47. #else 
  48.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  49.   PlaceWorldUnitInRing (Res-Hippopotamus, 12, 12)
  50. #endif
  51.  
  52.  
  53. #if Is2Players
  54. //////////////////////////////////////////////////////////////////////
  55. // 2 PLAYERS...
  56. //////////////////////////////////////////////////////////////////////
  57.  
  58. ResourceSeperation    6 
  59.  
  60. PlaceResourceInRing (Gold, 14, 16)
  61. PlaceResourceInRing (Iron, 15, 17)
  62.  
  63. PlaceResourceInRing (Iron, 35, 40)
  64. PlaceResourceInRing (Gold, 35, 40)
  65. PlaceResourceInRing (Stone, 25, 30)
  66.  
  67. //////////////////////////////////////////////////////////////////////
  68. // Placing Aggressive Animals
  69.  
  70. PlaceWorldUnitInRing (Res-Tiger, 33, 35)
  71. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  72.  
  73. //////////////////////////////////////////////////////////////////////
  74. // terrain definitions
  75. HeightMapSmoothness                    0
  76. #define        (kMaxIntElevation,            8)
  77. #define        (kElevationScale,                Between(.5, .5))
  78. #define        (kHeightMapChaos,                Between(15, 15))
  79.                                             
  80. #define        (kMinimumStartPositionToMapEdge        5)
  81. #define        (kOuterPushFromMapCenter        15)
  82. #define        (kInnerPushFromMapCenter         0)
  83. #define        (kConvergentSampleSize,            32) 
  84. #define        (kConvergentThreshold,            20000)        
  85.  
  86. //////////////////////////////////////////////////////////////////////
  87. // player definitions
  88. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  89. #define        (kPlayerInnerRadius,            0.7)
  90. #define        (kPlayerOuterRadius,            0.99)
  91. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  92. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  93. #define        (kPlayerLandChaos,            0.8)
  94. #define        (kPlayerLandClumps,            Between(2, 2))
  95. #define        (kPlayerFlatChaos,            0.8)
  96. #define        (kPlayerFlatClumps,            Between(1, 2))
  97. #define        (kPlayerTreePercentage,            0.04)
  98.  
  99.  
  100. //////////////////////////////////////////////////////////////////////
  101. // inner neutral definitions
  102. #define        (kNeutralInnerRadius,            0.2)
  103. #define        (kNeutralOuterRadius,            0.4)
  104. #define        (kNeutralOptimalFactor,            0.7)
  105. #define        (kNumInnerNeutrals,                 Between(20, 20))
  106. #define        (kInnerNeutralPercentLand,        0.2)
  107. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  108. #define        (kInnerNeutralTreePercentage,          0.15)
  109. #define        (kInnerNeutralLandChaos,        0.8)
  110. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  111. #define        (kInnerNeutralFlatChaos,        0.8)
  112. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  113.  
  114.  
  115. //////////////////////////////////////////////////////////////////////
  116. // outer neutral definitions
  117. #define        (kNumOuterNeutrals,            Between(14, 14))
  118. #define        (kOuterNeutralPercentLand,        0.2)
  119. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  120. #define        (kOuterNeutralTreePercentage,          0.25)
  121. #define        (kOuterNeutralLandChaos,        0.8)
  122. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  123. #define        (kOuterNeutralFlatChaos,        0.8)
  124. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  125.  
  126.  
  127. //////////////////////////////////////////////////////////////////////
  128. // resource definitions
  129. #define        (kMaxResourceElevation,            1)
  130. #define        (kResourceToEdgeDistance,        2)
  131. #define        (kResourceToWaterDistance,        3)
  132.  
  133. #define        (kAnimalPerPlayer,                0)
  134. #define        (kAnimalPerNeutral,                0)
  135.  
  136.  
  137. #define        (kBerryPerNeutral,                0)
  138.  
  139. #define        (kFishPerPlayer,                0)
  140. #define        (kFishPerNeutral,                0)
  141.  
  142. #define        (kGoldPerPlayer,                1)
  143. #define        (kGoldPerNeutral,                4)
  144.  
  145. #define        (kOilPerPlayer,                    0)
  146. #define        (kOilPerNeutral,                0)
  147.  
  148. #define        (kSteelPerPlayer,                1)
  149. #define        (kSteelPerNeutral,                4)
  150.  
  151. #define        (kStonePerPlayer,                1)
  152. #define        (kStonePerNeutral,                1)
  153.  
  154. #define        (kTreePerPlayer,                Between(2, 3))
  155. #define        (kTreePerNeutral,                0)
  156.  
  157. //////////////////////////////////////////////////////////////////////
  158. // forest definitions
  159. #define        (kForestFreeRadius,                7.0)
  160. #define        (kForestsPerPlayer,                1)
  161. #define        (kForestChaosLevel,                1)
  162. #define        (kMaxClumpsPerForest,                  2)
  163.  
  164. #elif Is3Players
  165. //////////////////////////////////////////////////////////////////////
  166. // 3 PLAYERS...
  167. //////////////////////////////////////////////////////////////////////
  168.  
  169. //////////////////////////////////////////////////////////////////////
  170. // Placing Aggressive Animals
  171.  
  172. ResourceSeperation    6 
  173.  
  174. PlaceWorldUnitInRing (Res-Tiger, 33, 35)
  175. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  176.  
  177. PlaceResourceInRing (Gold, 14, 16)
  178. PlaceResourceInRing (Iron, 15, 17)
  179.  
  180. PlaceResourceInRing (Iron, 35, 40)
  181. PlaceResourceInRing (Gold, 35, 40)
  182. PlaceResourceInRing (Stone, 30, 35)
  183.  
  184. //////////////////////////////////////////////////////////////////////
  185. // terrain definitions
  186. HeightMapSmoothness                    0
  187. #define        (kMaxIntElevation,            8)
  188. #define        (kElevationScale,                Between(.5, .5))
  189. #define        (kHeightMapChaos,                Between(15, 15))
  190.                                             
  191. #define        (kMinimumStartPositionToMapEdge        5)
  192. #define        (kOuterPushFromMapCenter        15)
  193. #define        (kInnerPushFromMapCenter         0)        
  194.  
  195. //////////////////////////////////////////////////////////////////////
  196. // player definitions
  197. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  198. #define        (kPlayerInnerRadius,            0.7)
  199. #define        (kPlayerOuterRadius,            0.99)
  200. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  201. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  202. #define        (kPlayerLandChaos,            0.8)
  203. #define        (kPlayerLandClumps,            Between(2, 2))
  204. #define        (kPlayerFlatChaos,            0.8)
  205. #define        (kPlayerFlatClumps,            Between(1, 2))
  206. #define        (kPlayerTreePercentage,            0.05)
  207.  
  208.  
  209. //////////////////////////////////////////////////////////////////////
  210. // inner neutral definitions
  211. #define        (kNeutralInnerRadius,            0.2)
  212. #define        (kNeutralOuterRadius,            0.4)
  213. #define        (kNeutralOptimalFactor,            0.7)
  214. #define        (kNumInnerNeutrals,                 Between(20, 20))
  215. #define        (kInnerNeutralPercentLand,        0.2)
  216. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  217. #define        (kInnerNeutralTreePercentage,          0.15)
  218. #define        (kInnerNeutralLandChaos,        0.8)
  219. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  220. #define        (kInnerNeutralFlatChaos,        0.8)
  221. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  222.  
  223.  
  224. //////////////////////////////////////////////////////////////////////
  225. // outer neutral definitions
  226. #define        (kNumOuterNeutrals,            Between(12, 12))
  227. #define        (kOuterNeutralPercentLand,        0.2)
  228. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  229. #define        (kOuterNeutralTreePercentage,          0.25)
  230. #define        (kOuterNeutralLandChaos,        0.8)
  231. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  232. #define        (kOuterNeutralFlatChaos,        0.8)
  233. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  234.  
  235.  
  236. //////////////////////////////////////////////////////////////////////
  237. // resource definitions
  238. #define        (kMaxResourceElevation,            1)
  239. #define        (kResourceToEdgeDistance,        2)
  240. #define        (kResourceToWaterDistance,        3)
  241.  
  242. #define        (kAnimalPerPlayer,                0)
  243. #define        (kAnimalPerNeutral,                0)
  244.  
  245.  
  246. #define        (kBerryPerNeutral,                0)
  247.  
  248. #define        (kFishPerPlayer,                0)
  249. #define        (kFishPerNeutral,                0)
  250.  
  251. #define        (kGoldPerPlayer,                1)
  252. #define        (kGoldPerNeutral,                4)
  253.  
  254. #define        (kOilPerPlayer,                    0)
  255. #define        (kOilPerNeutral,                0)
  256.  
  257. #define        (kSteelPerPlayer,                1)
  258. #define        (kSteelPerNeutral,                4)
  259.  
  260. #define        (kStonePerPlayer,                1)
  261. #define        (kStonePerNeutral,                1)
  262.  
  263. #define        (kTreePerPlayer,                Between(2, 3))
  264. #define        (kTreePerNeutral,                0)
  265.  
  266. //////////////////////////////////////////////////////////////////////
  267. // forest definitions
  268. #define        (kForestFreeRadius,                7.0)
  269. #define        (kForestsPerPlayer,                1)
  270. #define        (kForestChaosLevel,                1)
  271. #define        (kMaxClumpsPerForest,                  2)
  272.  
  273.  
  274. #elif Is4Players
  275. //////////////////////////////////////////////////////////////////////
  276. // 4 PLAYERS...
  277. //////////////////////////////////////////////////////////////////////
  278.  
  279. //////////////////////////////////////////////////////////////////////
  280. // Placing Aggressive Animals
  281.  
  282. ResourceSeperation    6 
  283.  
  284. PlaceWorldUnitInRing (Res-Tiger, 30, 32)
  285. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  286.  
  287. PlaceResourceInRing (Gold, 14, 16)
  288. PlaceResourceInRing (Iron, 15, 17)
  289.  
  290. PlaceResourceInRing (Iron, 30, 35)
  291. PlaceResourceInRing (Gold, 30, 35)
  292. PlaceResourceInRing (Stone, 25, 30)
  293.  
  294. //////////////////////////////////////////////////////////////////////
  295. // terrain definitions
  296. HeightMapSmoothness                    0
  297. #define        (kMaxIntElevation,            8)
  298. #define        (kElevationScale,                Between(.5, .5))
  299. #define        (kHeightMapChaos,                Between(15, 15))
  300.                                             
  301. #define        (kMinimumStartPositionToMapEdge        5)
  302. #define        (kOuterPushFromMapCenter        15)
  303. #define        (kInnerPushFromMapCenter         0)        
  304.  
  305. //////////////////////////////////////////////////////////////////////
  306. // player definitions
  307. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  308. #define        (kPlayerInnerRadius,            0.7)
  309. #define        (kPlayerOuterRadius,            0.99)
  310. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  311. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  312. #define        (kPlayerLandChaos,            0.8)
  313. #define        (kPlayerLandClumps,            Between(2, 2))
  314. #define        (kPlayerFlatChaos,            0.8)
  315. #define        (kPlayerFlatClumps,            Between(1, 2))
  316. #define        (kPlayerTreePercentage,            0.05)
  317.  
  318.  
  319. //////////////////////////////////////////////////////////////////////
  320. // inner neutral definitions
  321. #define        (kNeutralInnerRadius,            0.2)
  322. #define        (kNeutralOuterRadius,            0.4)
  323. #define        (kNeutralOptimalFactor,            0.7)
  324. #define        (kNumInnerNeutrals,                 Between(20, 20))
  325. #define        (kInnerNeutralPercentLand,        0.2)
  326. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  327. #define        (kInnerNeutralTreePercentage,          0.15)
  328. #define        (kInnerNeutralLandChaos,        0.8)
  329. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  330. #define        (kInnerNeutralFlatChaos,        0.8)
  331. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  332.  
  333.  
  334. //////////////////////////////////////////////////////////////////////
  335. // outer neutral definitions
  336. #define        (kNumOuterNeutrals,            Between(12, 12))
  337. #define        (kOuterNeutralPercentLand,        0.2)
  338. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  339. #define        (kOuterNeutralTreePercentage,          0.25)
  340. #define        (kOuterNeutralLandChaos,        0.8)
  341. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  342. #define        (kOuterNeutralFlatChaos,        0.8)
  343. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  344.  
  345.  
  346. //////////////////////////////////////////////////////////////////////
  347. // resource definitions
  348. #define        (kMaxResourceElevation,            1)
  349. #define        (kResourceToEdgeDistance,        2)
  350. #define        (kResourceToWaterDistance,        3)
  351.  
  352. #define        (kAnimalPerPlayer,                0)
  353. #define        (kAnimalPerNeutral,                0)
  354.  
  355.  
  356. #define        (kBerryPerNeutral,                0)
  357.  
  358. #define        (kFishPerPlayer,                0)
  359. #define        (kFishPerNeutral,                0)
  360.  
  361. #define        (kGoldPerPlayer,                1)
  362. #define        (kGoldPerNeutral,                4)
  363.  
  364. #define        (kOilPerPlayer,                    0)
  365. #define        (kOilPerNeutral,                0)
  366.  
  367. #define        (kSteelPerPlayer,                1)
  368. #define        (kSteelPerNeutral,                4)
  369.  
  370. #define        (kStonePerPlayer,                1)
  371. #define        (kStonePerNeutral,                0)
  372.  
  373. #define        (kTreePerPlayer,                Between(2, 3))
  374. #define        (kTreePerNeutral,                0)
  375.  
  376. //////////////////////////////////////////////////////////////////////
  377. // forest definitions
  378. #define        (kForestFreeRadius,                7.0)
  379. #define        (kForestsPerPlayer,                1)
  380. #define        (kForestChaosLevel,                1)
  381. #define        (kMaxClumpsPerForest,                  2)
  382.  
  383.  
  384. #elif Is5Players
  385. //////////////////////////////////////////////////////////////////////
  386. // 5 PLAYERS...
  387. //////////////////////////////////////////////////////////////////////
  388.  
  389. //////////////////////////////////////////////////////////////////////
  390. // Placing Aggressive Animals
  391.  
  392. ResourceSeperation    5 
  393.  
  394. PlaceWorldUnitInRing (Res-Tiger, 30, 32)
  395. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  396.  
  397. PlaceResourceInRing (Gold, 14, 16)
  398. PlaceResourceInRing (Iron, 15, 17)
  399.  
  400. //////////////////////////////////////////////////////////////////////
  401. // terrain definitions
  402. HeightMapSmoothness                    0
  403. #define        (kMaxIntElevation,            8)
  404. #define        (kElevationScale,                Between(.5, .5))
  405. #define        (kHeightMapChaos,                Between(15, 15))
  406.                                             
  407. #define        (kMinimumStartPositionToMapEdge        5)
  408. #define        (kOuterPushFromMapCenter        15)
  409. #define        (kInnerPushFromMapCenter         0)        
  410.  
  411. //////////////////////////////////////////////////////////////////////
  412. // player definitions
  413. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  414. #define        (kPlayerInnerRadius,            0.7)
  415. #define        (kPlayerOuterRadius,            0.99)
  416. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  417. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  418. #define        (kPlayerLandChaos,            0.8)
  419. #define        (kPlayerLandClumps,            Between(2, 2))
  420. #define        (kPlayerFlatChaos,            0.8)
  421. #define        (kPlayerFlatClumps,            Between(1, 2))
  422. #define        (kPlayerTreePercentage,            0.07)
  423.  
  424.  
  425. //////////////////////////////////////////////////////////////////////
  426. // inner neutral definitions
  427. #define        (kNeutralInnerRadius,            0.2)
  428. #define        (kNeutralOuterRadius,            0.4)
  429. #define        (kNeutralOptimalFactor,            0.7)
  430. #define        (kNumInnerNeutrals,                 Between(16, 16))
  431. #define        (kInnerNeutralPercentLand,        0.2)
  432. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  433. #define        (kInnerNeutralTreePercentage,          0.15)
  434. #define        (kInnerNeutralLandChaos,        0.8)
  435. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  436. #define        (kInnerNeutralFlatChaos,        0.8)
  437. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  438.  
  439.  
  440. //////////////////////////////////////////////////////////////////////
  441. // outer neutral definitions
  442. #define        (kNumOuterNeutrals,            Between(12, 12))
  443. #define        (kOuterNeutralPercentLand,        0.2)
  444. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  445. #define        (kOuterNeutralTreePercentage,          0.25)
  446. #define        (kOuterNeutralLandChaos,        0.8)
  447. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  448. #define        (kOuterNeutralFlatChaos,        0.8)
  449. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  450.  
  451.  
  452. //////////////////////////////////////////////////////////////////////
  453. // resource definitions
  454. #define        (kMaxResourceElevation,            1)
  455. #define        (kResourceToEdgeDistance,        2)
  456. #define        (kResourceToWaterDistance,        3)
  457.  
  458. #define        (kAnimalPerPlayer,                0)
  459. #define        (kAnimalPerNeutral,                0)
  460.  
  461.  
  462. #define        (kBerryPerNeutral,                0)
  463.  
  464. #define        (kFishPerPlayer,                0)
  465. #define        (kFishPerNeutral,                0)
  466.  
  467. #define        (kGoldPerPlayer,                1)
  468. #define        (kGoldPerNeutral,                8)
  469.  
  470. #define        (kOilPerPlayer,                    0)
  471. #define        (kOilPerNeutral,                0)
  472.  
  473. #define        (kSteelPerPlayer,                1)
  474. #define        (kSteelPerNeutral,                8)
  475.  
  476. #define        (kStonePerPlayer,                1)
  477. #define        (kStonePerNeutral,                2)
  478.  
  479. #define        (kTreePerPlayer,                Between(2, 3))
  480. #define        (kTreePerNeutral,                0)
  481.  
  482. //////////////////////////////////////////////////////////////////////
  483. // forest definitions
  484. #define        (kForestFreeRadius,                7.0)
  485. #define        (kForestsPerPlayer,                1)
  486. #define        (kForestChaosLevel,                1)
  487. #define        (kMaxClumpsPerForest,                  2)
  488.  
  489. #elif Is6Players
  490. //////////////////////////////////////////////////////////////////////
  491. // 6 PLAYERS...
  492. //////////////////////////////////////////////////////////////////////
  493.  
  494. ResourceSeperation    5 
  495.  
  496. //////////////////////////////////////////////////////////////////////
  497. // Placing Aggressive Animals
  498.  
  499. PlaceResourceInRing (Gold, 14, 16)
  500. PlaceResourceInRing (Iron, 15, 17)
  501.  
  502. PlaceWorldUnitInRing (Res-Tiger, 28, 29)
  503.  
  504. //////////////////////////////////////////////////////////////////////
  505. // terrain definitions
  506. HeightMapSmoothness                    0
  507. #define        (kMaxIntElevation,            8)
  508. #define        (kElevationScale,                Between(.5, .5))
  509. #define        (kHeightMapChaos,                Between(15, 15))
  510.                                             
  511. #define        (kMinimumStartPositionToMapEdge        5)
  512. #define        (kOuterPushFromMapCenter        15)
  513. #define        (kInnerPushFromMapCenter         0)        
  514.  
  515. //////////////////////////////////////////////////////////////////////
  516. // player definitions
  517. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  518. #define        (kPlayerInnerRadius,            0.7)
  519. #define        (kPlayerOuterRadius,            0.99)
  520. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  521. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  522. #define        (kPlayerLandChaos,            0.8)
  523. #define        (kPlayerLandClumps,            Between(2, 2))
  524. #define        (kPlayerFlatChaos,            0.8)
  525. #define        (kPlayerFlatClumps,            Between(1, 2))
  526. #define        (kPlayerTreePercentage,            0.05)
  527.  
  528.  
  529. //////////////////////////////////////////////////////////////////////
  530. // inner neutral definitions
  531. #define        (kNeutralInnerRadius,            0.2)
  532. #define        (kNeutralOuterRadius,            0.4)
  533. #define        (kNeutralOptimalFactor,            0.7)
  534. #define        (kNumInnerNeutrals,                 Between(16, 16))
  535. #define        (kInnerNeutralPercentLand,        0.2)
  536. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  537. #define        (kInnerNeutralTreePercentage,          0.08)
  538. #define        (kInnerNeutralLandChaos,        0.8)
  539. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  540. #define        (kInnerNeutralFlatChaos,        0.8)
  541. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  542.  
  543.  
  544. //////////////////////////////////////////////////////////////////////
  545. // outer neutral definitions
  546. #define        (kNumOuterNeutrals,            Between(12, 12))
  547. #define        (kOuterNeutralPercentLand,        0.2)
  548. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  549. #define        (kOuterNeutralTreePercentage,          0.25)
  550. #define        (kOuterNeutralLandChaos,        0.8)
  551. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  552. #define        (kOuterNeutralFlatChaos,        0.8)
  553. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  554.  
  555.  
  556. //////////////////////////////////////////////////////////////////////
  557. // resource definitions
  558. #define        (kMaxResourceElevation,            1)
  559. #define        (kResourceToEdgeDistance,        2)
  560. #define        (kResourceToWaterDistance,        3)
  561.  
  562. #define        (kAnimalPerPlayer,                0)
  563. #define        (kAnimalPerNeutral,                0)
  564.  
  565.  
  566. #define        (kBerryPerNeutral,                0)
  567.  
  568. #define        (kFishPerPlayer,                0)
  569. #define        (kFishPerNeutral,                0)
  570.  
  571. #define        (kGoldPerPlayer,                1)
  572. #define        (kGoldPerNeutral,                8)
  573.  
  574. #define        (kOilPerPlayer,                    0)
  575. #define        (kOilPerNeutral,                0)
  576.  
  577. #define        (kSteelPerPlayer,                1)
  578. #define        (kSteelPerNeutral,                8)
  579.  
  580. #define        (kStonePerPlayer,                1)
  581. #define        (kStonePerNeutral,                2)
  582.  
  583. #define        (kTreePerPlayer,                Between(2, 3))
  584. #define        (kTreePerNeutral,                0)
  585.  
  586. //////////////////////////////////////////////////////////////////////
  587. // forest definitions
  588. #define        (kForestFreeRadius,                7.0)
  589. #define        (kForestsPerPlayer,                1)
  590. #define        (kForestChaosLevel,                10)
  591. #define        (kMaxClumpsPerForest,                     2)
  592.  
  593. #elif Is7Players
  594. //////////////////////////////////////////////////////////////////////
  595. // 7 PLAYERS...
  596. //////////////////////////////////////////////////////////////////////
  597.  
  598. ResourceSeperation    5 
  599.  
  600. //////////////////////////////////////////////////////////////////////
  601. // Placing Aggressive Animals
  602.  
  603. PlaceWorldUnitInRing (Res-Tiger, 28, 28)
  604.  
  605. PlaceResourceInRing (Gold, 14, 16)
  606. PlaceResourceInRing (Iron, 15, 17)
  607.  
  608. //////////////////////////////////////////////////////////////////////
  609. // terrain definitions
  610. HeightMapSmoothness                    0
  611. #define        (kMaxIntElevation,            8)
  612. #define        (kElevationScale,                Between(.5, .5))
  613. #define        (kHeightMapChaos,                Between(15, 15))
  614.                                             
  615. #define        (kMinimumStartPositionToMapEdge        15)
  616. #define        (kOuterPushFromMapCenter        0)
  617. #define        (kInnerPushFromMapCenter         0)        
  618.  
  619. //////////////////////////////////////////////////////////////////////
  620. // player definitions
  621. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  622. #define        (kPlayerInnerRadius,            0.7)
  623. #define        (kPlayerOuterRadius,            0.99)
  624. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  625. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  626. #define        (kPlayerLandChaos,            0.8)
  627. #define        (kPlayerLandClumps,            Between(2, 2))
  628. #define        (kPlayerFlatChaos,            0.8)
  629. #define        (kPlayerFlatClumps,            Between(1, 2))
  630. #define        (kPlayerTreePercentage,            0.05)
  631.  
  632.  
  633. //////////////////////////////////////////////////////////////////////
  634. // inner neutral definitions
  635. #define        (kNeutralInnerRadius,            0.2)
  636. #define        (kNeutralOuterRadius,            0.4)
  637. #define        (kNeutralOptimalFactor,            0.7)
  638. #define        (kNumInnerNeutrals,                 Between(15, 15))
  639. #define        (kInnerNeutralPercentLand,        0.2)
  640. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  641. #define        (kInnerNeutralTreePercentage,          0.08)
  642. #define        (kInnerNeutralLandChaos,        0.8)
  643. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  644. #define        (kInnerNeutralFlatChaos,        0.8)
  645. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  646.  
  647.  
  648. //////////////////////////////////////////////////////////////////////
  649. // outer neutral definitions
  650. #define        (kNumOuterNeutrals,            Between(12, 12))
  651. #define        (kOuterNeutralPercentLand,        0.2)
  652. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  653. #define        (kOuterNeutralTreePercentage,          0.25)
  654. #define        (kOuterNeutralLandChaos,        0.8)
  655. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  656. #define        (kOuterNeutralFlatChaos,        0.8)
  657. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  658.  
  659.  
  660. //////////////////////////////////////////////////////////////////////
  661. // resource definitions
  662. #define        (kMaxResourceElevation,            1)
  663. #define        (kResourceToEdgeDistance,        2)
  664. #define        (kResourceToWaterDistance,        3)
  665.  
  666. #define        (kAnimalPerPlayer,                0)
  667. #define        (kAnimalPerNeutral,                0)
  668.  
  669.  
  670. #define        (kBerryPerNeutral,                0)
  671.  
  672. #define        (kFishPerPlayer,                0)
  673. #define        (kFishPerNeutral,                0)
  674.  
  675. #define        (kGoldPerPlayer,                1)
  676. #define        (kGoldPerNeutral,                8)
  677.  
  678. #define        (kOilPerPlayer,                    0)
  679. #define        (kOilPerNeutral,                0)
  680.  
  681. #define        (kSteelPerPlayer,                1)
  682. #define        (kSteelPerNeutral,                8)
  683.  
  684. #define        (kStonePerPlayer,                1)
  685. #define        (kStonePerNeutral,                2)
  686.  
  687. #define        (kTreePerPlayer,                Between(2, 3))
  688. #define        (kTreePerNeutral,                0)
  689.  
  690. //////////////////////////////////////////////////////////////////////
  691. // forest definitions
  692. #define        (kForestFreeRadius,                7.0)
  693. #define        (kForestsPerPlayer,                1)
  694. #define        (kForestChaosLevel,                10)
  695. #define        (kMaxClumpsPerForest,                     2)
  696.  
  697.  
  698. #elif Is8Players
  699. //////////////////////////////////////////////////////////////////////
  700. // 8 PLAYERS...
  701. //////////////////////////////////////////////////////////////////////
  702.  
  703. ResourceSeperation    4 
  704.  
  705. PlaceResourceInRing (Gold, 14, 16)
  706. PlaceResourceInRing (Iron, 15, 17)
  707.  
  708. //////////////////////////////////////////////////////////////////////
  709. // terrain definitions
  710. HeightMapSmoothness                    0
  711. #define        (kMaxIntElevation,            8)
  712. #define        (kElevationScale,                Between(.5, .5))
  713. #define        (kHeightMapChaos,                Between(15, 15))
  714.                                             
  715. #define        (kMinimumStartPositionToMapEdge        5)
  716. #define        (kOuterPushFromMapCenter        15)
  717. #define        (kInnerPushFromMapCenter         0)        
  718.  
  719. //////////////////////////////////////////////////////////////////////
  720. // player definitions
  721. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  722. #define        (kPlayerInnerRadius,            0.7)
  723. #define        (kPlayerOuterRadius,            0.99)
  724. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  725. #define        (kPlayerPercentFlat,            Between(0.8, 0.8))
  726. #define        (kPlayerLandChaos,            0.8)
  727. #define        (kPlayerLandClumps,            Between(2, 2))
  728. #define        (kPlayerFlatChaos,            0.8)
  729. #define        (kPlayerFlatClumps,            Between(1, 2))
  730. #define        (kPlayerTreePercentage,            0.05)
  731.  
  732.  
  733. //////////////////////////////////////////////////////////////////////
  734. // inner neutral definitions
  735. #define        (kNeutralInnerRadius,            0.2)
  736. #define        (kNeutralOuterRadius,            0.4)
  737. #define        (kNeutralOptimalFactor,            0.7)
  738. #define        (kNumInnerNeutrals,                 Between(16, 16))
  739. #define        (kInnerNeutralPercentLand,        0.2)
  740. #define        (kInnerNeutralPercentFlat,        Between(0.2, 0.2))
  741. #define        (kInnerNeutralTreePercentage,          0.08)
  742. #define        (kInnerNeutralLandChaos,        0.8)
  743. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  744. #define        (kInnerNeutralFlatChaos,        0.8)
  745. #define        (kInnerNeutralFlatClumps,        Between(1, 1))
  746.  
  747.  
  748. //////////////////////////////////////////////////////////////////////
  749. // outer neutral definitions
  750. #define        (kNumOuterNeutrals,            Between(12, 12))
  751. #define        (kOuterNeutralPercentLand,        0.2)
  752. #define        (kOuterNeutralPercentFlat,        Between(0.1, 0.1))
  753. #define        (kOuterNeutralTreePercentage,          0.25)
  754. #define        (kOuterNeutralLandChaos,        0.8)
  755. #define        (kOuterNeutralLandClumps,        Between(1, 1))
  756. #define        (kOuterNeutralFlatChaos,        0.8)
  757. #define        (kOuterNeutralFlatClumps,        Between(1, 1))
  758.  
  759.  
  760. //////////////////////////////////////////////////////////////////////
  761. // resource definitions
  762. #define        (kMaxResourceElevation,            1)
  763. #define        (kResourceToEdgeDistance,        2)
  764. #define        (kResourceToWaterDistance,        3)
  765.  
  766. #define        (kAnimalPerPlayer,                0)
  767. #define        (kAnimalPerNeutral,                0)
  768.  
  769.  
  770. #define        (kBerryPerNeutral,                0)
  771.  
  772. #define        (kFishPerPlayer,                0)
  773. #define        (kFishPerNeutral,                0)
  774.  
  775. #define        (kGoldPerPlayer,                1)
  776. #define        (kGoldPerNeutral,                8)
  777.  
  778. #define        (kOilPerPlayer,                    0)
  779. #define        (kOilPerNeutral,                0)
  780.  
  781. #define        (kSteelPerPlayer,                1)
  782. #define        (kSteelPerNeutral,                8)
  783.  
  784. #define        (kStonePerPlayer,                1)
  785. #define        (kStonePerNeutral,                1)
  786.  
  787. #define        (kTreePerPlayer,                Between(2, 3))
  788. #define        (kTreePerNeutral,                0)
  789.  
  790. //////////////////////////////////////////////////////////////////////
  791. // forest definitions
  792. #define        (kForestFreeRadius,                7.0)
  793. #define        (kForestsPerPlayer,                1)
  794. #define        (kForestChaosLevel,                10)
  795. #define        (kMaxClumpsPerForest,                  2)
  796.  
  797. #elif Is9Players
  798. //////////////////////////////////////////////////////////////////////
  799. // 9 PLAYERS...
  800. //////////////////////////////////////////////////////////////////////
  801.  
  802. //////////////////////////////////////////////////////////////////////
  803. // terrain definitions
  804. #define        (kMaxIntElevation,            12)
  805. #define        (kElevationScale,                Between(1, 1))
  806. #define        (kHeightMapChaos,                Between(20, 60))
  807.  
  808. #define        (kMinimumStartPositionToMapEdge    2)
  809. #define        (kOuterPushFromMapCenter        30)
  810. #define        (kInnerPushFromMapCenter         0)    
  811.                                             
  812. //////////////////////////////////////////////////////////////////////
  813. // player definitions
  814. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  815. #define        (kPlayerInnerRadius,            0.6)
  816. #define        (kPlayerOuterRadius,            0.93)
  817. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  818. #define        (kPlayerPercentFlat,            Between(.8, .8))
  819. #define        (kPlayerLandChaos,            0.8)
  820. #define        (kPlayerLandClumps,            Between(2, 2))
  821. #define        (kPlayerFlatChaos,            0.8)
  822. #define        (kPlayerFlatClumps,            Between(1, 2))
  823. #define        (kPlayerTreePercentage,            0.1)
  824.  
  825. //////////////////////////////////////////////////////////////////////
  826. // inner neutral definitions
  827. #define        (kNeutralInnerRadius,            0.1)
  828. #define        (kNeutralOuterRadius,            0.4)
  829. #define        (kNeutralOptimalFactor,            0.7)
  830. #define        (kNumInnerNeutrals,                 Between(14, 14))
  831. #define        (kInnerNeutralPercentLand,        0.17)
  832. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  833. #define        (kInnerNeutralTreePercentage,          0.2)
  834. #define        (kInnerNeutralLandChaos,        0.8)
  835. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  836. #define        (kInnerNeutralFlatChaos,        0.8)
  837. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  838.  
  839. //////////////////////////////////////////////////////////////////////
  840. // outer neutral definitions
  841. #define        (kNumOuterNeutrals,            Between(28, 28))
  842. #define        (kOuterNeutralPercentLand,        0.56)
  843. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  844. #define        (kOuterNeutralTreePercentage,          0.11)
  845. #define        (kOuterNeutralLandChaos,        0.8)
  846. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  847. #define        (kOuterNeutralFlatChaos,        0.8)
  848. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  849.  
  850. //////////////////////////////////////////////////////////////////////
  851. // resource definitions
  852. #define        (kMaxResourceElevation,            4)
  853. #define        (kResourceToEdgeDistance,        2)
  854. #define        (kResourceToWaterDistance,        4)
  855.  
  856. #define        (kAnimalPerPlayer,            0)
  857. #define        (kAnimalPerNeutral,            0)
  858.  
  859.  
  860. #define        (kBerryPerNeutral,            0)
  861.  
  862. #define        (kFishPerPlayer,                0)
  863. #define        (kFishPerNeutral,                0)
  864.  
  865. #define        (kGoldPerPlayer,                2)
  866. #define        (kGoldPerNeutral,                7)
  867.  
  868. #define        (kOilPerPlayer,                0)
  869. #define        (kOilPerNeutral,                0)
  870.  
  871. #define        (kSteelPerPlayer,                2)
  872. #define        (kSteelPerNeutral,            7)
  873.  
  874. #define        (kStonePerPlayer,                1)
  875. #define        (kStonePerNeutral,            6)
  876.  
  877. #define        (kTreePerPlayer,                0)
  878. #define        (kTreePerNeutral,                0)
  879.  
  880.  
  881. //////////////////////////////////////////////////////////////////////
  882. // forest definitions
  883. #define        (kForestFreeRadius,                8.0)
  884. #define        (kForestsPerPlayer,                1 )
  885. #define        (kForestChaosLevel,                0.5)
  886. #define        (kMaxClumpsPerForest,                  2)
  887.  
  888.  
  889. #elif Is10Players
  890. //////////////////////////////////////////////////////////////////////
  891. // 10 PLAYERS...
  892. //////////////////////////////////////////////////////////////////////
  893.  
  894. //////////////////////////////////////////////////////////////////////
  895. // terrain definitions
  896. #define        (kMaxIntElevation,            12)
  897. #define        (kElevationScale,                Between(1, 1))
  898. #define        (kHeightMapChaos,                Between(20, 60))
  899.  
  900. #define        (kMinimumStartPositionToMapEdge    2)
  901. #define        (kOuterPushFromMapCenter        30)
  902. #define        (kInnerPushFromMapCenter         0)    
  903.                                             
  904. //////////////////////////////////////////////////////////////////////
  905. // player definitions
  906. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  907. #define        (kPlayerInnerRadius,            0.6)
  908. #define        (kPlayerOuterRadius,            0.93)
  909. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  910. #define        (kPlayerPercentFlat,            Between(.8, .8))
  911. #define        (kPlayerLandChaos,            0.8)
  912. #define        (kPlayerLandClumps,            Between(2, 2))
  913. #define        (kPlayerFlatChaos,            0.8)
  914. #define        (kPlayerFlatClumps,            Between(1, 2))
  915. #define        (kPlayerTreePercentage,            0.1)
  916.  
  917. //////////////////////////////////////////////////////////////////////
  918. // inner neutral definitions
  919. #define        (kNeutralInnerRadius,            0.1)
  920. #define        (kNeutralOuterRadius,            0.4)
  921. #define        (kNeutralOptimalFactor,            0.7)
  922. #define        (kNumInnerNeutrals,                 Between(14, 14))
  923. #define        (kInnerNeutralPercentLand,        0.17)
  924. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  925. #define        (kInnerNeutralTreePercentage,          0.2)
  926. #define        (kInnerNeutralLandChaos,        0.8)
  927. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  928. #define        (kInnerNeutralFlatChaos,        0.8)
  929. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  930.  
  931. //////////////////////////////////////////////////////////////////////
  932. // outer neutral definitions
  933. #define        (kNumOuterNeutrals,            Between(28, 28))
  934. #define        (kOuterNeutralPercentLand,        0.56)
  935. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  936. #define        (kOuterNeutralTreePercentage,          0.11)
  937. #define        (kOuterNeutralLandChaos,        0.8)
  938. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  939. #define        (kOuterNeutralFlatChaos,        0.8)
  940. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  941.  
  942. //////////////////////////////////////////////////////////////////////
  943. // resource definitions
  944. #define        (kMaxResourceElevation,            4)
  945. #define        (kResourceToEdgeDistance,        2)
  946. #define        (kResourceToWaterDistance,        4)
  947.  
  948. #define        (kAnimalPerPlayer,            0)
  949. #define        (kAnimalPerNeutral,            0)
  950.  
  951.  
  952. #define        (kBerryPerNeutral,            0)
  953.  
  954. #define        (kFishPerPlayer,                0)
  955. #define        (kFishPerNeutral,                0)
  956.  
  957. #define        (kGoldPerPlayer,                2)
  958. #define        (kGoldPerNeutral,                7)
  959.  
  960. #define        (kOilPerPlayer,                0)
  961. #define        (kOilPerNeutral,                0)
  962.  
  963. #define        (kSteelPerPlayer,                2)
  964. #define        (kSteelPerNeutral,            7)
  965.  
  966. #define        (kStonePerPlayer,                1)
  967. #define        (kStonePerNeutral,            6)
  968.  
  969. #define        (kTreePerPlayer,                0)
  970. #define        (kTreePerNeutral,                0)
  971.  
  972.  
  973. //////////////////////////////////////////////////////////////////////
  974. // forest definitions
  975. #define        (kForestFreeRadius,                8.0)
  976. #define        (kForestsPerPlayer,                1 )
  977. #define        (kForestChaosLevel,                0.5)
  978. #define        (kMaxClumpsPerForest,                  2)
  979.  
  980.  
  981. #elif Is11Players
  982. //////////////////////////////////////////////////////////////////////
  983. // 11 PLAYERS...
  984. //////////////////////////////////////////////////////////////////////
  985.  
  986. //////////////////////////////////////////////////////////////////////
  987. // terrain definitions
  988. #define        (kMaxIntElevation,            12)
  989. #define        (kElevationScale,                Between(1, 1))
  990. #define        (kHeightMapChaos,                Between(20, 60))
  991.  
  992. #define        (kMinimumStartPositionToMapEdge    2)
  993. #define        (kOuterPushFromMapCenter        30)
  994. #define        (kInnerPushFromMapCenter         0)    
  995.                                             
  996. //////////////////////////////////////////////////////////////////////
  997. // player definitions
  998. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  999. #define        (kPlayerInnerRadius,            0.6)
  1000. #define        (kPlayerOuterRadius,            0.93)
  1001. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1002. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1003. #define        (kPlayerLandChaos,            0.8)
  1004. #define        (kPlayerLandClumps,            Between(2, 2))
  1005. #define        (kPlayerFlatChaos,            0.8)
  1006. #define        (kPlayerFlatClumps,            Between(1, 2))
  1007. #define        (kPlayerTreePercentage,            0.1)
  1008.  
  1009. //////////////////////////////////////////////////////////////////////
  1010. // inner neutral definitions
  1011. #define        (kNeutralInnerRadius,            0.1)
  1012. #define        (kNeutralOuterRadius,            0.4)
  1013. #define        (kNeutralOptimalFactor,            0.7)
  1014. #define        (kNumInnerNeutrals,                 Between(14, 14))
  1015. #define        (kInnerNeutralPercentLand,        0.17)
  1016. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1017. #define        (kInnerNeutralTreePercentage,          0.2)
  1018. #define        (kInnerNeutralLandChaos,        0.8)
  1019. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1020. #define        (kInnerNeutralFlatChaos,        0.8)
  1021. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1022.  
  1023. //////////////////////////////////////////////////////////////////////
  1024. // outer neutral definitions
  1025. #define        (kNumOuterNeutrals,            Between(28, 28))
  1026. #define        (kOuterNeutralPercentLand,        0.56)
  1027. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1028. #define        (kOuterNeutralTreePercentage,          0.11)
  1029. #define        (kOuterNeutralLandChaos,        0.8)
  1030. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1031. #define        (kOuterNeutralFlatChaos,        0.8)
  1032. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1033.  
  1034. //////////////////////////////////////////////////////////////////////
  1035. // resource definitions
  1036. #define        (kMaxResourceElevation,            4)
  1037. #define        (kResourceToEdgeDistance,        2)
  1038. #define        (kResourceToWaterDistance,        4)
  1039.  
  1040. #define        (kAnimalPerPlayer,            0)
  1041. #define        (kAnimalPerNeutral,            0)
  1042.  
  1043.  
  1044. #define        (kBerryPerNeutral,            0)
  1045.  
  1046. #define        (kFishPerPlayer,                0)
  1047. #define        (kFishPerNeutral,                0)
  1048.  
  1049. #define        (kGoldPerPlayer,                2)
  1050. #define        (kGoldPerNeutral,                7)
  1051.  
  1052. #define        (kOilPerPlayer,                0)
  1053. #define        (kOilPerNeutral,                0)
  1054.  
  1055. #define        (kSteelPerPlayer,                2)
  1056. #define        (kSteelPerNeutral,            7)
  1057.  
  1058. #define        (kStonePerPlayer,                1)
  1059. #define        (kStonePerNeutral,            6)
  1060.  
  1061. #define        (kTreePerPlayer,                0)
  1062. #define        (kTreePerNeutral,                0)
  1063.  
  1064.  
  1065. //////////////////////////////////////////////////////////////////////
  1066. // forest definitions
  1067. #define        (kForestFreeRadius,                8.0)
  1068. #define        (kForestsPerPlayer,                1 )
  1069. #define        (kForestChaosLevel,                0.5)
  1070. #define        (kMaxClumpsPerForest,                  2)
  1071.  
  1072.  
  1073. #elif Is12Players
  1074. //////////////////////////////////////////////////////////////////////
  1075. // 12 PLAYERS...
  1076. //////////////////////////////////////////////////////////////////////
  1077.  
  1078. //////////////////////////////////////////////////////////////////////
  1079. // terrain definitions
  1080. #define        (kMaxIntElevation,            12)
  1081. #define        (kElevationScale,                Between(1, 1))
  1082. #define        (kHeightMapChaos,                Between(20, 60))
  1083.  
  1084. #define        (kMinimumStartPositionToMapEdge    2)
  1085. #define        (kOuterPushFromMapCenter        30)
  1086. #define        (kInnerPushFromMapCenter         0)    
  1087.                                             
  1088. //////////////////////////////////////////////////////////////////////
  1089. // player definitions
  1090. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  1091. #define        (kPlayerInnerRadius,            0.6)
  1092. #define        (kPlayerOuterRadius,            0.93)
  1093. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1094. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1095. #define        (kPlayerLandChaos,            0.8)
  1096. #define        (kPlayerLandClumps,            Between(2, 2))
  1097. #define        (kPlayerFlatChaos,            0.8)
  1098. #define        (kPlayerFlatClumps,            Between(1, 2))
  1099. #define        (kPlayerTreePercentage,            0.1)
  1100.  
  1101. //////////////////////////////////////////////////////////////////////
  1102. // inner neutral definitions
  1103. #define        (kNeutralInnerRadius,            0.1)
  1104. #define        (kNeutralOuterRadius,            0.4)
  1105. #define        (kNeutralOptimalFactor,            0.7)
  1106. #define        (kNumInnerNeutrals,                 Between(14, 14))
  1107. #define        (kInnerNeutralPercentLand,        0.17)
  1108. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1109. #define        (kInnerNeutralTreePercentage,          0.2)
  1110. #define        (kInnerNeutralLandChaos,        0.8)
  1111. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1112. #define        (kInnerNeutralFlatChaos,        0.8)
  1113. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1114.  
  1115. //////////////////////////////////////////////////////////////////////
  1116. // outer neutral definitions
  1117. #define        (kNumOuterNeutrals,            Between(28, 28))
  1118. #define        (kOuterNeutralPercentLand,        0.56)
  1119. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1120. #define        (kOuterNeutralTreePercentage,          0.11)
  1121. #define        (kOuterNeutralLandChaos,        0.8)
  1122. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1123. #define        (kOuterNeutralFlatChaos,        0.8)
  1124. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1125.  
  1126. //////////////////////////////////////////////////////////////////////
  1127. // resource definitions
  1128. #define        (kMaxResourceElevation,            4)
  1129. #define        (kResourceToEdgeDistance,        2)
  1130. #define        (kResourceToWaterDistance,        4)
  1131.  
  1132. #define        (kAnimalPerPlayer,            0)
  1133. #define        (kAnimalPerNeutral,            0)
  1134.  
  1135.  
  1136. #define        (kBerryPerNeutral,            0)
  1137.  
  1138. #define        (kFishPerPlayer,                0)
  1139. #define        (kFishPerNeutral,                0)
  1140.  
  1141. #define        (kGoldPerPlayer,                2)
  1142. #define        (kGoldPerNeutral,                7)
  1143.  
  1144. #define        (kOilPerPlayer,                0)
  1145. #define        (kOilPerNeutral,                0)
  1146.  
  1147. #define        (kSteelPerPlayer,                2)
  1148. #define        (kSteelPerNeutral,            7)
  1149.  
  1150. #define        (kStonePerPlayer,                1)
  1151. #define        (kStonePerNeutral,            6)
  1152.  
  1153. #define        (kTreePerPlayer,                0)
  1154. #define        (kTreePerNeutral,                0)
  1155.  
  1156.  
  1157. //////////////////////////////////////////////////////////////////////
  1158. // forest definitions
  1159. #define        (kForestFreeRadius,                8.0)
  1160. #define        (kForestsPerPlayer,                1 )
  1161. #define        (kForestChaosLevel,                0.5)
  1162. #define        (kMaxClumpsPerForest,                  2)
  1163.  
  1164.  
  1165. #elif Is13Players
  1166. //////////////////////////////////////////////////////////////////////
  1167. // 13 PLAYERS...
  1168. //////////////////////////////////////////////////////////////////////
  1169.  
  1170. //////////////////////////////////////////////////////////////////////
  1171. // terrain definitions
  1172. #define        (kMaxIntElevation,            12)
  1173. #define        (kElevationScale,                Between(1, 1))
  1174. #define        (kHeightMapChaos,                Between(20, 60))
  1175.  
  1176. #define        (kMinimumStartPositionToMapEdge    2)
  1177. #define        (kOuterPushFromMapCenter        30)
  1178. #define        (kInnerPushFromMapCenter         0)    
  1179.                                             
  1180. //////////////////////////////////////////////////////////////////////
  1181. // player definitions
  1182. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  1183. #define        (kPlayerInnerRadius,            0.6)
  1184. #define        (kPlayerOuterRadius,            0.93)
  1185. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1186. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1187. #define        (kPlayerLandChaos,            0.8)
  1188. #define        (kPlayerLandClumps,            Between(2, 2))
  1189. #define        (kPlayerFlatChaos,            0.8)
  1190. #define        (kPlayerFlatClumps,            Between(1, 2))
  1191. #define        (kPlayerTreePercentage,            0.1)
  1192.  
  1193. //////////////////////////////////////////////////////////////////////
  1194. // inner neutral definitions
  1195. #define        (kNeutralInnerRadius,            0.1)
  1196. #define        (kNeutralOuterRadius,            0.4)
  1197. #define        (kNeutralOptimalFactor,            0.7)
  1198. #define        (kNumInnerNeutrals,                 Between(14, 14))
  1199. #define        (kInnerNeutralPercentLand,        0.17)
  1200. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1201. #define        (kInnerNeutralTreePercentage,          0.2)
  1202. #define        (kInnerNeutralLandChaos,        0.8)
  1203. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1204. #define        (kInnerNeutralFlatChaos,        0.8)
  1205. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1206.  
  1207. //////////////////////////////////////////////////////////////////////
  1208. // outer neutral definitions
  1209. #define        (kNumOuterNeutrals,            Between(28, 28))
  1210. #define        (kOuterNeutralPercentLand,        0.56)
  1211. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1212. #define        (kOuterNeutralTreePercentage,          0.11)
  1213. #define        (kOuterNeutralLandChaos,        0.8)
  1214. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1215. #define        (kOuterNeutralFlatChaos,        0.8)
  1216. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1217.  
  1218. //////////////////////////////////////////////////////////////////////
  1219. // resource definitions
  1220. #define        (kMaxResourceElevation,            4)
  1221. #define        (kResourceToEdgeDistance,        2)
  1222. #define        (kResourceToWaterDistance,        4)
  1223.  
  1224. #define        (kAnimalPerPlayer,            0)
  1225. #define        (kAnimalPerNeutral,            0)
  1226.  
  1227.  
  1228. #define        (kBerryPerNeutral,            0)
  1229.  
  1230. #define        (kFishPerPlayer,                0)
  1231. #define        (kFishPerNeutral,                0)
  1232.  
  1233. #define        (kGoldPerPlayer,                2)
  1234. #define        (kGoldPerNeutral,                7)
  1235.  
  1236. #define        (kOilPerPlayer,                0)
  1237. #define        (kOilPerNeutral,                0)
  1238.  
  1239. #define        (kSteelPerPlayer,                2)
  1240. #define        (kSteelPerNeutral,            7)
  1241.  
  1242. #define        (kStonePerPlayer,                1)
  1243. #define        (kStonePerNeutral,            6)
  1244.  
  1245. #define        (kTreePerPlayer,                0)
  1246. #define        (kTreePerNeutral,                0)
  1247.  
  1248.  
  1249. //////////////////////////////////////////////////////////////////////
  1250. // forest definitions
  1251. #define        (kForestFreeRadius,                8.0)
  1252. #define        (kForestsPerPlayer,                1 )
  1253. #define        (kForestChaosLevel,                0.5)
  1254. #define        (kMaxClumpsPerForest,                  2)
  1255.  
  1256. #elif Is14Players
  1257. //////////////////////////////////////////////////////////////////////
  1258. // 14 PLAYERS...
  1259. //////////////////////////////////////////////////////////////////////
  1260.  
  1261. //////////////////////////////////////////////////////////////////////
  1262. // terrain definitions
  1263. #define        (kMaxIntElevation,            12)
  1264. #define        (kElevationScale,                Between(1, 1))
  1265. #define        (kHeightMapChaos,                Between(20, 60))
  1266.  
  1267. #define        (kMinimumStartPositionToMapEdge    2)
  1268. #define        (kOuterPushFromMapCenter        30)
  1269. #define        (kInnerPushFromMapCenter         0)    
  1270.                                             
  1271. //////////////////////////////////////////////////////////////////////
  1272. // player definitions
  1273. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  1274. #define        (kPlayerInnerRadius,            0.6)
  1275. #define        (kPlayerOuterRadius,            0.93)
  1276. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1277. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1278. #define        (kPlayerLandChaos,            0.8)
  1279. #define        (kPlayerLandClumps,            Between(2, 2))
  1280. #define        (kPlayerFlatChaos,            0.8)
  1281. #define        (kPlayerFlatClumps,            Between(1, 2))
  1282. #define        (kPlayerTreePercentage,            0.1)
  1283.  
  1284. //////////////////////////////////////////////////////////////////////
  1285. // inner neutral definitions
  1286. #define        (kNeutralInnerRadius,            0.1)
  1287. #define        (kNeutralOuterRadius,            0.4)
  1288. #define        (kNeutralOptimalFactor,            0.7)
  1289. #define        (kNumInnerNeutrals,                 Between(14, 14))
  1290. #define        (kInnerNeutralPercentLand,        0.17)
  1291. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1292. #define        (kInnerNeutralTreePercentage,          0.2)
  1293. #define        (kInnerNeutralLandChaos,        0.8)
  1294. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1295. #define        (kInnerNeutralFlatChaos,        0.8)
  1296. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1297.  
  1298. //////////////////////////////////////////////////////////////////////
  1299. // outer neutral definitions
  1300. #define        (kNumOuterNeutrals,            Between(28, 28))
  1301. #define        (kOuterNeutralPercentLand,        0.56)
  1302. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1303. #define        (kOuterNeutralTreePercentage,          0.11)
  1304. #define        (kOuterNeutralLandChaos,        0.8)
  1305. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1306. #define        (kOuterNeutralFlatChaos,        0.8)
  1307. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1308.  
  1309. //////////////////////////////////////////////////////////////////////
  1310. // resource definitions
  1311. #define        (kMaxResourceElevation,            4)
  1312. #define        (kResourceToEdgeDistance,        2)
  1313. #define        (kResourceToWaterDistance,        4)
  1314.  
  1315. #define        (kAnimalPerPlayer,            0)
  1316. #define        (kAnimalPerNeutral,            0)
  1317.  
  1318.  
  1319. #define        (kBerryPerNeutral,            0)
  1320.  
  1321. #define        (kFishPerPlayer,                0)
  1322. #define        (kFishPerNeutral,                0)
  1323.  
  1324. #define        (kGoldPerPlayer,                2)
  1325. #define        (kGoldPerNeutral,                7)
  1326.  
  1327. #define        (kOilPerPlayer,                0)
  1328. #define        (kOilPerNeutral,                0)
  1329.  
  1330. #define        (kSteelPerPlayer,                2)
  1331. #define        (kSteelPerNeutral,            7)
  1332.  
  1333. #define        (kStonePerPlayer,                1)
  1334. #define        (kStonePerNeutral,            6)
  1335.  
  1336. #define        (kTreePerPlayer,                0)
  1337. #define        (kTreePerNeutral,                0)
  1338.  
  1339.  
  1340. //////////////////////////////////////////////////////////////////////
  1341. // forest definitions
  1342. #define        (kForestFreeRadius,                8.0)
  1343. #define        (kForestsPerPlayer,                1 )
  1344. #define        (kForestChaosLevel,                0.5)
  1345. #define        (kMaxClumpsPerForest,                  2)
  1346.  
  1347.  
  1348. #elif Is15Players
  1349. //////////////////////////////////////////////////////////////////////
  1350. // 15 PLAYERS...
  1351. //////////////////////////////////////////////////////////////////////
  1352.  
  1353. //////////////////////////////////////////////////////////////////////
  1354. // terrain definitions
  1355. #define        (kMaxIntElevation,            12)
  1356. #define        (kElevationScale,                Between(1, 1))
  1357. #define        (kHeightMapChaos,                Between(20, 60))
  1358.  
  1359. #define        (kMinimumStartPositionToMapEdge    2)
  1360. #define        (kOuterPushFromMapCenter        30)
  1361. #define        (kInnerPushFromMapCenter         0)    
  1362.                                             
  1363. //////////////////////////////////////////////////////////////////////
  1364. // player definitions
  1365. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  1366. #define        (kPlayerInnerRadius,            0.6)
  1367. #define        (kPlayerOuterRadius,            0.93)
  1368. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1369. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1370. #define        (kPlayerLandChaos,            0.8)
  1371. #define        (kPlayerLandClumps,            Between(2, 2))
  1372. #define        (kPlayerFlatChaos,            0.8)
  1373. #define        (kPlayerFlatClumps,            Between(1, 2))
  1374. #define        (kPlayerTreePercentage,            0.1)
  1375.  
  1376. //////////////////////////////////////////////////////////////////////
  1377. // inner neutral definitions
  1378. #define        (kNeutralInnerRadius,            0.1)
  1379. #define        (kNeutralOuterRadius,            0.4)
  1380. #define        (kNeutralOptimalFactor,            0.7)
  1381. #define        (kNumInnerNeutrals,                 Between(14, 14))
  1382. #define        (kInnerNeutralPercentLand,        0.17)
  1383. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1384. #define        (kInnerNeutralTreePercentage,          0.2)
  1385. #define        (kInnerNeutralLandChaos,        0.8)
  1386. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1387. #define        (kInnerNeutralFlatChaos,        0.8)
  1388. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1389.  
  1390. //////////////////////////////////////////////////////////////////////
  1391. // outer neutral definitions
  1392. #define        (kNumOuterNeutrals,            Between(28, 28))
  1393. #define        (kOuterNeutralPercentLand,        0.56)
  1394. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1395. #define        (kOuterNeutralTreePercentage,          0.11)
  1396. #define        (kOuterNeutralLandChaos,        0.8)
  1397. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1398. #define        (kOuterNeutralFlatChaos,        0.8)
  1399. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1400.  
  1401. //////////////////////////////////////////////////////////////////////
  1402. // resource definitions
  1403. #define        (kMaxResourceElevation,            4)
  1404. #define        (kResourceToEdgeDistance,        2)
  1405. #define        (kResourceToWaterDistance,        4)
  1406.  
  1407. #define        (kAnimalPerPlayer,            0)
  1408. #define        (kAnimalPerNeutral,            0)
  1409.  
  1410.  
  1411.  
  1412. #define        (kBerryPerNeutral,            0)
  1413.  
  1414. #define        (kFishPerPlayer,                0)
  1415. #define        (kFishPerNeutral,                0)
  1416.  
  1417. #define        (kGoldPerPlayer,                2)
  1418. #define        (kGoldPerNeutral,                7)
  1419.  
  1420. #define        (kOilPerPlayer,                0)
  1421. #define        (kOilPerNeutral,                0)
  1422.  
  1423. #define        (kSteelPerPlayer,                2)
  1424. #define        (kSteelPerNeutral,            7)
  1425.  
  1426. #define        (kStonePerPlayer,                1)
  1427. #define        (kStonePerNeutral,            6)
  1428.  
  1429. #define        (kTreePerPlayer,                0)
  1430. #define        (kTreePerNeutral,                0)
  1431.  
  1432.  
  1433. //////////////////////////////////////////////////////////////////////
  1434. // forest definitions
  1435. #define        (kForestFreeRadius,                8.0)
  1436. #define        (kForestsPerPlayer,                1 )
  1437. #define        (kForestChaosLevel,                0.5)
  1438. #define        (kMaxClumpsPerForest,                  2)
  1439.  
  1440.  
  1441. #elif Is16Players
  1442. //////////////////////////////////////////////////////////////////////
  1443. // 16 PLAYERS...
  1444. //////////////////////////////////////////////////////////////////////
  1445.  
  1446. //////////////////////////////////////////////////////////////////////
  1447. // terrain definitions
  1448. #define        (kMaxIntElevation,            12)
  1449. #define        (kElevationScale,                Between(1, 1))
  1450. #define        (kHeightMapChaos,                Between(20, 60))
  1451.  
  1452. #define        (kMinimumStartPositionToMapEdge    2)
  1453. #define        (kOuterPushFromMapCenter        30)
  1454. #define        (kInnerPushFromMapCenter         0)    
  1455.                                             
  1456. //////////////////////////////////////////////////////////////////////
  1457. // player definitions
  1458. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  1459. #define        (kPlayerInnerRadius,            0.6)
  1460. #define        (kPlayerOuterRadius,            0.93)
  1461. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1462. #define        (kPlayerPercentFlat,            Between(.8, .8))
  1463. #define        (kPlayerLandChaos,            0.8)
  1464. #define        (kPlayerLandClumps,            Between(2, 2))
  1465. #define        (kPlayerFlatChaos,            0.8)
  1466. #define        (kPlayerFlatClumps,            Between(1, 2))
  1467. #define        (kPlayerTreePercentage,            0.1)
  1468.  
  1469. //////////////////////////////////////////////////////////////////////
  1470. // inner neutral definitions
  1471. #define        (kNeutralInnerRadius,            0.1)
  1472. #define        (kNeutralOuterRadius,            0.4)
  1473. #define        (kNeutralOptimalFactor,            0.7)
  1474. #define        (kNumInnerNeutrals,                 Between(14, 14))
  1475. #define        (kInnerNeutralPercentLand,        0.17)
  1476. #define        (kInnerNeutralPercentFlat,        Between(0.8, 0.8))
  1477. #define        (kInnerNeutralTreePercentage,          0.2)
  1478. #define        (kInnerNeutralLandChaos,        0.8)
  1479. #define        (kInnerNeutralLandClumps,        Between(2, 2))
  1480. #define        (kInnerNeutralFlatChaos,        0.8)
  1481. #define        (kInnerNeutralFlatClumps,        Between(1, 2))
  1482.  
  1483. //////////////////////////////////////////////////////////////////////
  1484. // outer neutral definitions
  1485. #define        (kNumOuterNeutrals,            Between(28, 28))
  1486. #define        (kOuterNeutralPercentLand,        0.56)
  1487. #define        (kOuterNeutralPercentFlat,        Between(0.9, 0.9))
  1488. #define        (kOuterNeutralTreePercentage,          0.11)
  1489. #define        (kOuterNeutralLandChaos,        0.8)
  1490. #define        (kOuterNeutralLandClumps,        Between(2, 2))
  1491. #define        (kOuterNeutralFlatChaos,        0.8)
  1492. #define        (kOuterNeutralFlatClumps,        Between(1, 2))
  1493.  
  1494. //////////////////////////////////////////////////////////////////////
  1495. // resource definitions
  1496. #define        (kMaxResourceElevation,            4)
  1497. #define        (kResourceToEdgeDistance,        2)
  1498. #define        (kResourceToWaterDistance,        4)
  1499.  
  1500. #define        (kAnimalPerPlayer,            0)
  1501. #define        (kAnimalPerNeutral,            0)
  1502.  
  1503.  
  1504. #define        (kBerryPerNeutral,            0)
  1505.  
  1506. #define        (kFishPerPlayer,                0)
  1507. #define        (kFishPerNeutral,                0)
  1508.  
  1509. #define        (kGoldPerPlayer,                2)
  1510. #define        (kGoldPerNeutral,                7)
  1511.  
  1512. #define        (kOilPerPlayer,                0)
  1513. #define        (kOilPerNeutral,                0)
  1514.  
  1515. #define        (kSteelPerPlayer,                2)
  1516. #define        (kSteelPerNeutral,            7)
  1517.  
  1518. #define        (kStonePerPlayer,                1)
  1519. #define        (kStonePerNeutral,            6)
  1520.  
  1521. #define        (kTreePerPlayer,                0)
  1522. #define        (kTreePerNeutral,                0)
  1523.  
  1524.  
  1525. //////////////////////////////////////////////////////////////////////
  1526. // forest definitions
  1527. #define        (kForestFreeRadius,                8.0)
  1528. #define        (kForestsPerPlayer,                1 )
  1529. #define        (kForestChaosLevel,                0.5)
  1530. #define        (kMaxClumpsPerForest,                  2)
  1531.  
  1532.  
  1533. //////////////////////////////////////////////////////////////////////
  1534. // End of if...elif... command
  1535. #endif
  1536.  
  1537. #endif        // NOTDEFINED(PLAINS_MEDIUM_RMV)